home *** CD-ROM | disk | FTP | other *** search
/ MacFormat España 15 / macformat_15.iso / Shareware Internet / Desarrolladores / gray image 2.1 / SimpleWindow.cc < prev    next >
Text File  |  1995-07-30  |  9KB  |  326 lines
  1. /*
  2.  ***********************************************************************
  3.  *
  4.  *
  5.  *            Simple Window Class
  6.  *        
  7.  *
  8.  ***********************************************************************
  9.  */
  10.  
  11. #include "image.h"
  12. #include "mymenv.h"
  13. #include "window.h"
  14. #include <PictUtil.h>
  15.  
  16. /*
  17.  *----------------------------------------------------------------------
  18.  *                Service functions
  19.  */
  20.  
  21.                 // Getting a bounding rectangle of an image
  22. ScreenRect::ScreenRect(const IMAGE& image)
  23. {
  24.   top = 0;
  25.   bottom = top + image.q_nrows();
  26.   left = 0;
  27.   right = left + image.q_ncols();
  28. }
  29.  
  30.                 // Create a rectangle of given height/width
  31.                 // positioned at the origin
  32. ScreenRect::ScreenRect(const rowcol& heightwidth)
  33. {
  34.   left = top = 0;
  35.   bottom = heightwidth.row();
  36.   right  = heightwidth.col();
  37. }
  38.  
  39.                     // Create a rectangle of given height/width
  40.                     // positioned at a given point
  41. ScreenRect::ScreenRect(const rowcol& origin, const rowcol& heightwidth)
  42. {
  43.   top  = origin.row();
  44.   left = origin.col();
  45.   bottom = top+heightwidth.row();
  46.   right  = left+heightwidth.col();
  47. }
  48.  
  49.  
  50.                     // Shifting a rectangle by the same amount
  51.                     // in X and Y
  52. ScreenRect& ScreenRect::operator += (const int offset)
  53. { 
  54.   top += offset; bottom += offset; left += offset; right += offset;
  55.   return *this;
  56. }
  57.  
  58.  
  59.                     // Print what rectangle is this
  60. void ScreenRect::print(const char * title) const
  61. {
  62.   alert("Rectangle %s (%d,%d) - (%d,%d)",title,top,left,bottom,right);
  63. }
  64.  
  65.  
  66.  
  67.  
  68. /*
  69.  *----------------------------------------------------------------------
  70.  *    A generic simple window that can be dragged around the screen
  71.  *        and closed by clicking a "go-away" button
  72.  * No other events are handled, redefine the event handler if necessary.
  73.  */
  74.  
  75.                 // Create a color window of the specified size and title
  76.                 // Note, the upper left corner of 'rect' must
  77.                 // NOT be (0,0)!
  78. ScreenWindow::ScreenWindow(ScreenRect rect, const char * title)
  79. {
  80.   const int window_offset = 100;        // Cannot be 0 or small!
  81.   this_window = NewCWindow(nil,rect += window_offset,(Pstr)title,
  82.                TRUE,noGrowDocProc,
  83.                (WindowPtr)(-1),TRUE,(long)this);
  84.   assert( this_window != 0 );
  85.   SetPort(this_window);
  86.   SelectWindow(this_window);
  87. }
  88.  
  89.                 // Create a color window from a resource template
  90. ScreenWindow::ScreenWindow(const short resource_id)
  91. {
  92.   this_window = GetNewCWindow(resource_id,nil,(WindowPtr)(-1));
  93.   SetWRefCon(this_window,(long)this);
  94.   assert( this_window != 0 );
  95.   SetPort(this_window);
  96.   SelectWindow(this_window);
  97. }
  98.  
  99.  
  100.  
  101.                 // Close the window and clean up the rubble
  102. ScreenWindow::~ScreenWindow(void)
  103. {
  104.   assert( this_window != 0 );
  105.   DisposeWindow(this_window);
  106.   this_window = 0;
  107. }
  108.  
  109.  
  110.                 // Event handling loop. Returns only when the
  111.                 // window is to be destroyed
  112. void ScreenWindow::handle(void)
  113. {
  114.   const long event_timeout = 20;
  115.   EventRecord    theEvent;
  116.  
  117.   for(;;)
  118.   {
  119.     if( !WaitNextEvent(everyEvent, &theEvent, event_timeout, nil) )
  120.      if( handle_null_event(theEvent.when) )
  121.        continue;
  122.      else
  123.        return;
  124.     switch( theEvent.what )
  125.     {
  126.       case kHighLevelEvent:    // All High-level events we're going to receive
  127.            // do_well( AEProcessAppleEvent(&theEvent) ); // are Apple events
  128.            break;
  129.  
  130.       case mouseDown:
  131.        if( !handle_mouse_down(theEvent) )
  132.          return;        // Window is to be closed (go-away buttin clicked)
  133.        break;
  134.             
  135.       case updateEvt:
  136.        if( this_window == (WindowPtr)theEvent.message )
  137.          update();
  138.        break;
  139.  
  140.       case keyDown:
  141.       case autoKey:
  142.        if( !handle_key_down(theEvent) )
  143.          return;        // a "quit" key must've been pressed
  144.        break;
  145.                         
  146.       case activateEvt:
  147.        if( this_window == (WindowPtr)theEvent.message )
  148.          activate(theEvent.modifiers & 0x01);
  149.        break;
  150.       }  
  151.   }
  152. }
  153.  
  154.                 // Handle "mouse-down" events
  155.                 // Returns FALSE if the user clicked within the
  156.                 // go-away region of our window. Otherwise,
  157.                 // returns TRUE
  158.                 // Handles dragging if necessary and system clicks
  159. Boolean ScreenWindow::handle_mouse_down(const EventRecord& the_event)
  160. {
  161.   WindowPtr    wp;
  162.   short        windowPart = FindWindow (the_event.where, &wp);
  163.     
  164.   switch (windowPart)
  165.   {
  166.     case inSysWindow: 
  167.          SystemClick(&the_event, wp);
  168.      break;
  169.         
  170.     case inMenuBar:
  171.          break;                // Don't handle it yet
  172.  
  173.     case inContent:
  174.      break;
  175.           
  176.     case inDrag:
  177.      if( wp == this_window )
  178.        drag(the_event.where);
  179.      break;
  180.                       
  181.     case inGoAway:
  182.      return FALSE;
  183.   }
  184.   return TRUE;
  185. }
  186.  
  187.                 // Handles key_down & auto_key events. Return FALSE
  188.                 // if the window is to be closed down
  189. Boolean ScreenWindow::handle_key_down(const EventRecord& the_event)
  190. {
  191.   return FALSE;                // Any key kills the application, sorry
  192. }
  193.  
  194.  
  195.                 // Handles null events, when nothing happens for some
  196.                 // time. Return FALSE when it's time to die
  197. Boolean ScreenWindow::handle_null_event(const long event_time)
  198. {
  199.   return TRUE;                            // Keep going
  200. }
  201.  
  202.             // Private window parts
  203.                 // Handle an update event - redraw the window
  204.                 // A virtual function draw() is called to do
  205.                 // the actual redrawing
  206. void ScreenWindow::update(void)
  207. {
  208.   GrafPtr    savePort;
  209.     
  210.   GetPort(&savePort);
  211.   SetPort(this_window);
  212.   BeginUpdate(this_window);
  213.   draw();
  214.   EndUpdate(this_window);
  215.   SetPort(savePort);
  216. }
  217.  
  218.                 // Make the entire window being redrawn
  219. void ScreenWindow::refresh(void)
  220. {
  221. //    EraseRect(&this_window->portRect);
  222.   InvalRect(&this_window->portRect);            
  223. }
  224.  
  225.                 // Handle an activate or deactivate event
  226. void ScreenWindow::activate (const Boolean go_active)
  227. {
  228.   if( go_active )
  229.     SetPort(this_window);
  230. }
  231.  
  232.  
  233. /*
  234.  *----------------------------------------------------------------------
  235.  *        A simple window with an offscreen window buffer
  236.  */
  237.  
  238.                     // Allocate the buffer for the offscreen
  239.                     // drawing and load CLUT (if clut_id != 0)
  240. OffScreenWindow::OffScreenWindow
  241.     (ScreenRect rect, const char * title, const short clut_id)
  242.     : ScreenWindow(rect,title), graf_world(nil)
  243. {
  244.   CTabHandle clut_handle = nil;
  245.   if( clut_id != 0 )
  246.   {                // try to get a user CLUT with that resource id
  247.     clut_handle = GetCTable(clut_id);
  248.     assert( clut_handle != 0 );
  249.     SetWinColor(our_window(),(WinCTab**)clut_handle);
  250.   }
  251.   do_well( NewGWorld(&graf_world,8,rect,clut_handle,nil,0) );
  252.   assert( graf_world != (void *)0 );
  253.  
  254. //    if( clut_handle != nil )
  255. //      DisposCTable(clut_handle);        // CLUT has been copied, and can be disposed of now
  256.                 // But careful! CLUT is associated with the window
  257.                 // by SetWinColor(), so we don't dispose of it
  258.  
  259.                     // Get hold of the offscreen pixmap
  260.   pixmap = GetGWorldPixMap(graf_world);        // and make sure it looks like
  261.   assert( pixmap != nil && *pixmap != nil );    // we can use it
  262.  
  263.   assert( (**pixmap).cmpCount == 1 );            // We have a color table index
  264.   assert( !PixMap32Bit(pixmap) );
  265.  
  266.   _height = abs((**pixmap).bounds.top - (**pixmap).bounds.bottom);
  267.   _width  = abs((**pixmap).bounds.right - (**pixmap).bounds.left);
  268.   _bytes_per_row = (**pixmap).rowBytes & 0x7fff;
  269.  
  270.   assert( _height > 0 && _height < 10000 );         // Just to play safe
  271.   assert( _width > 0 && _width <= _bytes_per_row );    
  272.  
  273.   activate_palette();                    // Activate palette for the window
  274. }
  275.  
  276.                     // Dispose of the offscreen buffer
  277. OffScreenWindow::~OffScreenWindow(void)
  278. {
  279.   assert( graf_world != nil );
  280.   DisposeGWorld(graf_world);
  281.   graf_world = nil;
  282.   PaletteHandle window_palette = GetPalette(our_window());
  283.   if( window_palette != nil )        // dispose of our palette if was allocated
  284.   {
  285.     SetPalette(our_window(),nil,FALSE);
  286.     DisposePalette(window_palette);
  287.   }
  288.   pixmap = nil;
  289.   _height = _width = _bytes_per_row = 0;
  290. }
  291.  
  292.             // Make sure that the colors of our off-screen
  293.             // buffer would be displayed properly (or close enough)
  294.             // on screen
  295. void OffScreenWindow::activate_palette(void)
  296. {
  297.   CTabHandle window_ctab = (**pixmap).pmTable;
  298.   assert( window_ctab != nil && *window_ctab != nil );
  299.  
  300.   PaletteHandle palette = NewPalette((**window_ctab).ctSize,window_ctab,pmTolerant+pmExplicit,0);
  301.   assert( palette != nil );
  302.   SetPalette(our_window(),palette,TRUE);
  303.   do_well( QDError() );
  304.   ActivatePalette(our_window());    
  305.   do_well( QDError() );
  306. }
  307.  
  308.  
  309.             // Get a bounding rectangle for the window
  310. ScreenRect OffScreenWindow::q_bounds(void) const
  311. {
  312.   return (**pixmap).bounds;
  313. }
  314.  
  315.  
  316.                 // Actual drawing - moving the picture from the
  317.                 // offscreen grafworld to the onscreen one
  318. void OffScreenWindow::draw(void)
  319. {
  320.   assert( LockPixels(pixmap) );
  321.   Rect& pixmap_rect = (**pixmap).bounds;
  322.   CopyBits((const BitMap *)*pixmap, &qd.thePort->portBits, &pixmap_rect, 
  323.         &our_window()->portRect, /*ditherCopy*/ srcCopy, nil);
  324.   UnlockPixels(pixmap);
  325. }
  326.